Here is the thread we will follow: a number can be written down in many different ways — and the way you write it changes what you can do with it.

That was true for Roman numerals. It is just as true for the floating-point formats inside a modern AI chip.

Rome counted like this: I, V, X, L, C, D, M.

No zero. No place value — the position of a symbol barely matters, only which symbols appear and in what combination.

Try multiplying MDCLXVI by XLIV in your head. Now try 1666 × 44. The second one is not just easier — it is a genuinely different kind of thinking.

Every numeral system so far shares the same gap: no symbol for nothing.

Without a zero, there is no clean way to write a number as a position-dependent code — and without position, arithmetic stays a craft for specialists, not a procedure anyone can follow.

Here is the real leap: the same ten symbols, re-used, mean something different depending on where they sit.

106 and 160 use identical digits. Position alone carries the meaning.

This single idea — a small, finite alphabet whose meaning depends on position — is the one that modern computing was built on top of.

Binary is just another positional system — base 2 instead of base 10. Only two symbols: 0 and 1.

That turns out to be the whole point. Building a reliable physical device with ten stable, distinguishable states is hard. Building one with two — voltage on, voltage off — is comparatively easy, cheap, and extremely reliable at enormous scale.

Every transistor in every chip is, at heart, a two-state switch pretending to be one of Leibniz's digits.

So far: how a culture chooses to write a number. Now: how a machine chooses to store one — and why, in a modern AI system, that choice is no longer a historical curiosity.

It is an engineering decision with real, measurable consequences.

Integer formats store whole numbers exactly. int8: one byte, 256 distinct values — typically -128 to 127.

Floating-point formats trade some of that exactness for enormous range: a sign bit, an exponent, and a mantissa (the significant digits) — the same idea as scientific notation, just in binary.

More bits generally buys you more precision, more range, or both. Fewer bits buys you speed and memory — at a cost.

Both fp16 and bf16 use 16 bits total — half the size of ordinary fp32 — but split those bits differently.

fp16 (IEEE half precision): 1 sign + 5 exponent + 10 mantissa bits. More precision, a narrower range — values that are too large or too small simply overflow to infinity or zero.

bf16 ("brain float", from Google): 1 sign + 8 exponent + 7 mantissa bits. The same exponent range as full 32-bit floats, less precision — far more forgiving during the unstable arithmetic of training a neural network.

Same bit budget. Different trade-off between "how exact" and "how big."

Models are usually trained in fp16, bf16, or fp32 — the precision that stability during training needs.

Once trained, they are often quantized down to int8 for inference (actually running the model): roughly a quarter of the memory of fp32, and hardware built for int8 can push through far more operations per second than the same silicon running floating point.

The accuracy cost is usually small. The speed and energy savings, at the scale a real deployment runs at, are not.

Take a real, current piece of edge-AI hardware: NVIDIA's Jetson AGX Orin (64GB module).

NVIDIA's own published figure: up to 275 TOPS (trillion operations per second) running INT8, with structured sparsity.

Switch the same chip to FP16 / BF16 and achievable throughput drops — roughly by half, since each floating-point operation occupies more of the tensor core's datapath than an 8-bit integer one.

Same transistors. Same chip. The number format you choose to compute in changes your real-world throughput by a factor of two or more.

Pythagoras claimed number was the hidden structure of reality.

Three thousand years later, the question "what exactly is this number, and how many bits does it cost to represent it" is no longer philosophy — it decides how fast your model runs, how much it costs to train, and how much energy it burns doing so.

The history of numerals is, in a very literal sense, the history of computation.